home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / PROGRAM / DJINC106.ARJ / FIX16.H < prev    next >
C/C++ Source or Header  |  1992-03-29  |  13KB  |  638 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2. /* 
  3. Copyright (C) 1988 Free Software Foundation
  4.     written by Kurt Baudendistel (gt-eedsp!baud@gatech.edu)
  5.     adapted for libg++ by Doug Lea (dl@rocky.oswego.edu)
  6.  
  7. This file is part of the GNU C++ Library.  This library is free
  8. software; you can redistribute it and/or modify it under the terms of
  9. the GNU Library General Public License as published by the Free
  10. Software Foundation; either version 2 of the License, or (at your
  11. option) any later version.  This library is distributed in the hope
  12. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  13. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14. PURPOSE.  See the GNU Library General Public License for more details.
  15. You should have received a copy of the GNU Library General Public
  16. License along with this library; if not, write to the Free Software
  17. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  19.  
  20. #ifndef _Fix16_h
  21. #ifdef __GNUG__
  22. #pragma interface
  23. #endif
  24. #define _Fix16_h 1
  25.  
  26. #include <stream.h>
  27. #include <std.h>
  28.  
  29. // constant definitions
  30.  
  31. #define Fix16_fs     ((double)((unsigned)(1 << 15)))
  32.  
  33. #define Fix16_msb    (1 << 15)
  34. #define Fix16_m_max    ((1 << 15) - 1)
  35. #define Fix16_m_min    ((short)(1 << 15))
  36.  
  37. #define Fix16_mult    Fix16_fs
  38. #define Fix16_div    (1./Fix16_fs)
  39. #define Fix16_max    (1. - .5/Fix16_fs)
  40. #define Fix16_min    (-1.)
  41.  
  42.  
  43. #define Fix32_fs     ((double)((unsigned long)(1 << 31)))
  44.  
  45. #define Fix32_msb    ((unsigned long)(1 << 31))
  46. #define Fix32_m_max    ((1 << 31) - 1)
  47. #define Fix32_m_min    ((long)(1 << 31))
  48.  
  49. #define Fix32_mult    Fix32_fs
  50. #define Fix32_div    (1./Fix32_fs)
  51. #define Fix32_max    (1. - .5/Fix32_fs)
  52. #define Fix32_min    (-1.)
  53.  
  54.  
  55. //
  56. // Fix16    class: 16-bit Fixed point data type
  57. //
  58. //    consists of a 16-bit mantissa (sign bit & 15 data bits).
  59. //
  60.  
  61. class Fix16 
  62. { 
  63.   friend class          Fix32;
  64.  
  65.   short                 m;
  66.  
  67.   short                 round(double d);
  68.   short                 assign(double d);
  69.                         Fix16(short i);
  70.                         Fix16(int i);
  71.  
  72.          operator       double();
  73.  
  74.  
  75. public:
  76.                         Fix16();
  77.                         Fix16(Fix16&  f);
  78.                         Fix16(double d);
  79.                         Fix16(Fix32& f);
  80.  
  81.                         ~Fix16();
  82.  
  83.   Fix16&                operator=(Fix16&  f);
  84.   Fix16&                operator=(double d);
  85.   Fix16&                operator=(Fix32& f);
  86.  
  87.   friend short&         mantissa(Fix16&  f);
  88.   friend double         value(Fix16&  f);
  89.  
  90.   Fix16                 operator +  ();
  91.   Fix16                 operator -  ();
  92.  
  93.   friend Fix16          operator +  (Fix16&  f, Fix16&  g);
  94.   friend Fix16          operator -  (Fix16&  f, Fix16&  g);
  95.   friend Fix32          operator *  (Fix16&  f, Fix16&  g);
  96.   friend Fix16          operator /  (Fix16&  f, Fix16&  g);
  97.   friend Fix16          operator << (Fix16&  f, int b);
  98.   friend Fix16          operator >> (Fix16&  f, int b);
  99.  
  100.   Fix16&                operator += (Fix16&  f);
  101.   Fix16&                operator -= (Fix16&  f);
  102.   Fix16&                operator *= (Fix16& );
  103.   Fix16&                operator /= (Fix16&  f);
  104.   
  105.   Fix16&                operator <<=(int b);
  106.   Fix16&                operator >>=(int b);
  107.  
  108.   friend int            operator == (Fix16&  f, Fix16&  g);
  109.   friend int            operator != (Fix16&  f, Fix16&  g);
  110.   friend int            operator >= (Fix16&  f, Fix16&  g);
  111.   friend int            operator <= (Fix16&  f, Fix16&  g);
  112.   friend int            operator >  (Fix16&  f, Fix16&  g);
  113.   friend int            operator <  (Fix16&  f, Fix16&  g);
  114.  
  115.   friend istream&       operator >> (istream& s, Fix16&  f);
  116.   friend ostream&       operator << (ostream& s, Fix16&  f);
  117.  
  118.   void                  overflow(short&);
  119.   void                  range_error(short&);
  120.  
  121.   friend Fix16          operator *  (Fix16&  f, int g);
  122.   friend Fix16          operator *  (int g, Fix16&  f);
  123.   Fix16&                operator *= (int g);
  124. };
  125.  
  126.  
  127. //
  128. // Fix32 class: 32-bit Fixed point data type
  129. //
  130. //    consists of a 32-bit mantissa (sign bit & 31 data bits).
  131. //
  132.  
  133. class Fix32 
  134. { 
  135.   friend class         Fix16;
  136.  
  137.   long                 m;
  138.  
  139.   long                 round(double d);
  140.   long                 assign(double d);
  141.  
  142.                        Fix32(long i);
  143.                        operator double();
  144.  
  145.  
  146. public:
  147.                        Fix32();
  148.                        Fix32(Fix32& f);
  149.                        Fix32(Fix16&  f);
  150.                        Fix32(double d);
  151.                        ~Fix32();
  152.  
  153.   Fix32&               operator =  (Fix32& f);
  154.   Fix32&               operator =  (Fix16&  f);
  155.   Fix32&               operator =  (double d);
  156.  
  157.   friend long&         mantissa(Fix32& f);
  158.   friend double        value(Fix32& f);
  159.  
  160.   Fix32                operator +  ();
  161.   Fix32                operator -  ();
  162.  
  163.   friend Fix32         operator +  (Fix32& f, Fix32& g);
  164.   friend Fix32         operator -  (Fix32& f, Fix32& g);
  165.   friend Fix32         operator *  (Fix32& f, Fix32& g);
  166.   friend Fix32         operator /  (Fix32& f, Fix32& g);
  167.   friend Fix32         operator << (Fix32& f, int b);
  168.   friend Fix32         operator >> (Fix32& f, int b);
  169.  
  170.   friend Fix32         operator *  (Fix16&  f, Fix16&  g);
  171.  
  172.   Fix32&               operator += (Fix32& f);
  173.   Fix32&               operator -= (Fix32& f);
  174.   Fix32&               operator *= (Fix32& f);
  175.   Fix32&               operator /= (Fix32& f);
  176.   Fix32&               operator <<=(int b);
  177.   Fix32&               operator >>=(int b);
  178.  
  179.   friend int           operator == (Fix32& f, Fix32& g);
  180.   friend int           operator != (Fix32& f, Fix32& g);
  181.   friend int           operator >= (Fix32& f, Fix32& g);
  182.   friend int           operator <= (Fix32& f, Fix32& g);
  183.   friend int           operator >  (Fix32& f, Fix32& g);
  184.   friend int           operator <  (Fix32& f, Fix32& g);
  185.  
  186.   friend istream&      operator >> (istream& s, Fix32& f);
  187.   friend ostream&      operator << (ostream& s, Fix32& f);
  188.  
  189.   void                 overflow(long& i);
  190.   void                 range_error(long& i);
  191.  
  192.   friend Fix32          operator *  (Fix32&  f, int g);
  193.   friend Fix32          operator *  (int g, Fix32&  f);
  194.   Fix32&                operator *= (int g);
  195. };
  196.  
  197. // active error handler declarations
  198.  
  199. typedef void (*Fix16_peh)(short&);
  200. typedef void (*Fix32_peh)(long&);
  201.  
  202. extern Fix16_peh Fix16_overflow_handler;
  203. extern Fix32_peh Fix32_overflow_handler;
  204.  
  205. extern Fix16_peh Fix16_range_error_handler;
  206. extern Fix32_peh Fix32_range_error_handler;
  207.  
  208. #if defined(SHORT_NAMES) || defined(VMS)
  209. #define    set_overflow_handler    sohndl
  210. #define set_range_error_handler    srnghdl
  211. #endif
  212.  
  213.  
  214. // error handler declarations
  215.  
  216. extern Fix16_peh set_Fix16_overflow_handler(Fix16_peh);
  217. extern Fix32_peh set_Fix32_overflow_handler(Fix32_peh);
  218. extern void set_overflow_handler(Fix16_peh, Fix32_peh);
  219.  
  220. extern Fix16_peh set_Fix16_range_error_handler(Fix16_peh);
  221. extern Fix32_peh set_Fix32_range_error_handler(Fix32_peh);
  222. extern void set_range_error_handler(Fix16_peh, Fix32_peh);
  223.  
  224. extern void
  225.   Fix16_ignore(short&),
  226.   Fix16_overflow_saturate(short&),
  227.   Fix16_overflow_warning_saturate(short&),
  228.   Fix16_warning(short&),
  229.   Fix16_abort(short&);
  230.  
  231. extern void
  232.   Fix32_ignore(long&),
  233.   Fix32_overflow_saturate(long&),
  234.   Fix32_overflow_warning_saturate(long&),
  235.   Fix32_warning(long&),
  236.   Fix32_abort(long&);
  237.  
  238.  
  239. inline Fix16::~Fix16() {}
  240.  
  241. inline short Fix16::round(double d)
  242. { 
  243.   return short( (d >= 0)? d + 0.5 : d - 0.5); 
  244. }
  245.  
  246. inline Fix16::Fix16(short i)        
  247. { 
  248.   m = i; 
  249. }
  250.  
  251. inline Fix16::Fix16(int i)        
  252. { 
  253.   m = i; 
  254. }
  255.  
  256. inline Fix16::operator double() 
  257. { 
  258.   return  Fix16_div * m; 
  259. }
  260.  
  261. inline Fix16::Fix16()                 
  262. { 
  263.   m = 0; 
  264. }
  265.  
  266. inline Fix16::Fix16(Fix16&  f)        
  267. { 
  268.   m = f.m; 
  269. }
  270.  
  271. inline Fix16::Fix16(double d)        
  272. {
  273.   m = assign(d);
  274. }
  275.  
  276.  
  277. inline Fix16&  Fix16::operator=(Fix16&  f)    
  278. { 
  279.   m = f.m; 
  280.   return *this; 
  281. }
  282.  
  283. inline Fix16&  Fix16::operator=(double d) 
  284. { 
  285.   m = assign(d); 
  286.   return *this; 
  287. }
  288.  
  289.  
  290. inline Fix32::Fix32()                
  291. { 
  292.   m = 0;
  293. }
  294.  
  295. inline Fix32::Fix32(long i)        
  296. { 
  297.   m = i;
  298. }
  299.  
  300. inline Fix32:: operator double()        
  301. { 
  302.   return Fix32_div * m;
  303. }
  304.  
  305.  
  306. inline Fix32::Fix32(Fix32& f)        
  307. { 
  308.   m = f.m;
  309. }
  310.  
  311. inline Fix32::Fix32(Fix16&  f)    
  312. { 
  313.   m = long(f.m) << 16;
  314. }
  315.  
  316. inline Fix32::Fix32(double d)        
  317. { 
  318.   m = assign(d);
  319. }
  320.  
  321. inline Fix16::Fix16(Fix32& f)        
  322. { 
  323.   m = f.m >> 16; 
  324. }
  325.  
  326.  
  327. inline Fix16&  Fix16::operator=(Fix32& f)
  328. { 
  329.   m = f.m >> 16; 
  330.   return *this; 
  331. }
  332.  
  333. inline Fix32& Fix32::operator=(Fix32& f)    
  334. { 
  335.   m = f.m;
  336.   return *this; 
  337. }
  338.  
  339. inline Fix32& Fix32::operator=(Fix16&  f)    
  340. { 
  341.   m = long(f.m) << 16;
  342.   return *this;
  343. }
  344.  
  345. inline Fix32& Fix32::operator=(double d)    
  346. { 
  347.   m = assign(d);
  348.   return *this; 
  349. }
  350.  
  351. inline short& mantissa(Fix16&  f)    
  352. { 
  353.   return f.m; 
  354. }
  355.  
  356. inline double value(Fix16&  f)        
  357. { 
  358.   return double(f); 
  359. }
  360.  
  361. inline Fix16 Fix16::operator+()         
  362. { 
  363.   return m; 
  364. }
  365.  
  366. inline Fix16 Fix16::operator-()         
  367. { 
  368.   return -m; 
  369. }
  370.  
  371. inline Fix16 operator+(Fix16&  f, Fix16&  g) 
  372. {
  373.   short sum = f.m + g.m;
  374.   if ( (f.m ^ sum) & (g.m ^ sum) & Fix16_msb )
  375.     f.overflow(sum);
  376.   return sum;
  377. }
  378.  
  379. inline Fix16 operator-(Fix16&  f, Fix16&  g) 
  380. {
  381.   short sum = f.m - g.m;
  382.   if ( (f.m ^ sum) & (-g.m ^ sum) & Fix16_msb )
  383.     f.overflow(sum);
  384.   return sum;
  385. }
  386.  
  387. inline Fix32 operator*(Fix16&  f, Fix16&  g)
  388. { 
  389.   return Fix32( long( long(f.m) * long(g.m) << 1)); 
  390. }
  391.  
  392. inline Fix16 operator<<(Fix16& a, int b)     
  393. { 
  394.   return a.m << b; 
  395. }
  396.  
  397. inline Fix16 operator>>(Fix16& a, int b)     
  398. { 
  399.   return a.m >> b; 
  400. }
  401.  
  402. inline  Fix16&  Fix16:: operator+=(Fix16&  f)
  403. { 
  404.   return *this = *this + f; 
  405. }
  406.  
  407. inline Fix16&  Fix16:: operator-=(Fix16&  f)     
  408. { 
  409.   return *this = *this - f; 
  410. }
  411.  
  412. inline Fix16& Fix16::operator*=(Fix16& f)     
  413. { 
  414.   return *this = *this * f; 
  415. }
  416.  
  417. inline Fix16&  Fix16:: operator/=(Fix16&  f)     
  418. { 
  419.   return *this = *this / f; 
  420. }
  421.  
  422. inline Fix16&  Fix16:: operator<<=(int b)    
  423. { 
  424.   return *this = *this << b;
  425. }
  426.  
  427. inline Fix16&  Fix16:: operator>>=(int b)    
  428. { 
  429.   return *this = *this >> b;
  430. }
  431.  
  432. inline int operator==(Fix16&  f, Fix16&  g)    
  433. { 
  434.   return f.m == g.m;
  435. }
  436.  
  437. inline int operator!=(Fix16&  f, Fix16&  g)    
  438. { 
  439.   return f.m != g.m;
  440. }
  441.  
  442. inline int operator>=(Fix16&  f, Fix16&  g)    
  443. { 
  444.   return f.m >= g.m;
  445. }
  446.  
  447. inline int operator<=(Fix16&  f, Fix16&  g)    
  448. { 
  449.   return f.m <= g.m;
  450. }
  451.  
  452. inline int operator>(Fix16&  f, Fix16&  g)    
  453. { 
  454.   return f.m > g.m;
  455. }
  456.  
  457. inline int operator<(Fix16&  f, Fix16&  g)    
  458. { 
  459.   return f.m < g.m;
  460. }
  461.  
  462. inline istream&  operator>>(istream& s, Fix16&  f)
  463. { 
  464.   double d;
  465.   s >> d; 
  466.   f = d; 
  467.   return s; 
  468. }
  469.  
  470. inline ostream&  operator<<(ostream& s, Fix16&  f)
  471. { 
  472.   return s << double(f);
  473. }
  474.  
  475.  
  476. inline Fix16 operator*(Fix16&  f, int g)
  477. {
  478.   return Fix16(short(f.m * g));
  479. }
  480.  
  481. inline Fix16 operator*(int g, Fix16&  f)
  482. {
  483.   return f * g;
  484. }
  485.  
  486.  
  487. inline Fix16& Fix16::operator*=(int g)
  488. {
  489.   return *this = *this * g;
  490. }
  491.  
  492. inline Fix32::~Fix32() {}
  493.  
  494. inline long Fix32::round(double d)
  495. { 
  496.   return long( (d >= 0)? d + 0.5 : d - 0.5);
  497. }
  498.  
  499.  
  500. inline long& mantissa(Fix32& f)    
  501. { 
  502.   return f.m;
  503. }
  504.  
  505. inline double value(Fix32& f)        
  506. { 
  507.   return double(f);
  508. }
  509.  
  510. inline Fix32 Fix32::operator+()         
  511. { 
  512.   return m;
  513. }
  514.  
  515. inline Fix32 Fix32::operator-()         
  516. { 
  517.   return -m;
  518. }
  519.  
  520. inline Fix32 operator+(Fix32& f, Fix32& g) 
  521. {
  522.   long sum = f.m + g.m;
  523.   if ( (f.m ^ sum) & (g.m ^ sum) & Fix32_msb )
  524.     f.overflow(sum);
  525.   return sum;
  526. }
  527.  
  528. inline Fix32 operator-(Fix32& f, Fix32& g) 
  529. {
  530.   long sum = f.m - g.m;
  531.   if ( (f.m ^ sum) & (-g.m ^ sum) & Fix32_msb )
  532.     f.overflow(sum);
  533.   return sum;
  534. }
  535.  
  536. inline Fix32 operator<<(Fix32& a, int b)     
  537. { 
  538.   return a.m << b;
  539. }
  540.  
  541. inline Fix32 operator>>(Fix32& a, int b)     
  542. { 
  543.   return a.m >> b;
  544. }
  545.  
  546. inline Fix32& Fix32::operator+=(Fix32& f)     
  547. { 
  548.   return *this = *this + f;
  549. }
  550.  
  551. inline Fix32& Fix32::operator-=(Fix32& f)     
  552. { 
  553.   return *this = *this - f;
  554. }
  555.  
  556. inline Fix32& Fix32::operator*=(Fix32& f)     
  557. { 
  558.   return *this = *this * f;
  559. }
  560.  
  561. inline Fix32& Fix32::operator/=(Fix32& f)     
  562. { 
  563.   return *this = *this / f;
  564. }
  565.  
  566.  
  567. inline Fix32& Fix32::operator<<=(int b)    
  568. { 
  569.   return *this = *this << b;
  570. }
  571.  
  572. inline Fix32& Fix32::operator>>=(int b)    
  573. { 
  574.   return *this = *this >> b;
  575. }
  576.  
  577. inline int operator==(Fix32& f, Fix32& g)    
  578. { 
  579.   return f.m == g.m;
  580. }
  581.  
  582. inline int operator!=(Fix32& f, Fix32& g)    
  583. { 
  584.   return f.m != g.m;
  585. }
  586.  
  587. inline int operator>=(Fix32& f, Fix32& g)    
  588. { 
  589.   return f.m >= g.m;
  590. }
  591.  
  592. inline int operator<=(Fix32& f, Fix32& g)    
  593. { 
  594.   return f.m <= g.m;
  595. }
  596.  
  597. inline int operator>(Fix32& f, Fix32& g)    
  598. { 
  599.   return f.m > g.m;
  600. }
  601.  
  602. inline int operator<(Fix32& f, Fix32& g)    
  603. { 
  604.   return f.m < g.m;
  605. }
  606.  
  607. inline istream& operator>>(istream& s, Fix32& f)
  608. { 
  609.   double d;
  610.   s >> d; 
  611.   f = d; 
  612.   return s; 
  613. }
  614.  
  615. inline ostream& operator<<(ostream& s, Fix32& f)
  616. { 
  617.   return s << double(f);
  618. }
  619.  
  620. inline Fix32 operator*(Fix32&  f, int g)
  621. {
  622.   return Fix32(long(f.m * g));
  623. }
  624.  
  625. inline Fix32 operator*(int g, Fix32&  f)
  626. {
  627.   return f * g;
  628. }
  629.  
  630.  
  631.  
  632. inline Fix32& Fix32::operator*=(int g)
  633. {
  634.   return *this = *this * g;
  635. }
  636.  
  637. #endif
  638.